# -*- coding: utf-8 -*-
# INF 8007 lab 1 - Mikaêl Guillemot et Thibaut Stimpfling 

    # On peut maintenant mettre en forme le texte brut
    # On retire les espaces/points du debut/fin
    # On remplace l'ensemble des passage a la ligne, "-" et "'" par des espaces
    # On divise le texte en une liste constituee de chacune des phrases
    # On en deduit le nombre de phrases via la longueur de la liste

import urllib


def open_file(path,type_encodage, message):
    print "Lecture du fichier "+message +" dans le chemin " + path
    try :
        file_in = open(path)
        if type_encodage !="utf-8":
            file_in=file_in.read().decode('latin1 ').encode ('utf8 ')
        else :
            file_in =file_in.read()
        print "Lecture complétée"
        return file_in
    except SyntaxError :
        print "Fichier introuvable"
    except : # Tous les cas non gérés 
        print "Erreur lors de l'ouverture du fichier. Arrêt de l'exécution de la fonction"
        
        
# Fonction de traitement du texte 
# Paramètre d'entrée : texte mis en forme
# Paramètre de retour : liste contenant 
#                        # Liste des mots non trouvés dans le lexique
#                        # Nombre de mots dans le texte traités
#                        # Nombre de syllabes dans le texte 

def line_processing (texte):
    # Initialisation de paramètres
    espaceur = "</BR>\n"
    mots = 0 
    syllabes = 0
    resultat=[]
    # Gestion de exceptions 
    liste = texte.split(".")
    nphrases = len(liste) # OK
    try :
        # Pour chacune des phrases contenue dans la liste
        for line in liste :
            liste_mots = split_list_mots(line)                    # Découpage d'une phrase en une liste contenant les mots de celle-ci
            result = lookup_list_in_dic(liste_mots, dic)        # 1 ème phase de recherche dans le dictionnaire pour chacun des mots contenus
            mots += result[1][0]                                # Récuppération du nombre de mots de la recherche 
            syllabes += result[1][1]                            # Récuppération du nombre de syllabe de la recherche
            result = last_lookup(result[0],dic)                    # 2 nd lookup sur les mots 
            mots += result[1][0]                                # Nombre de mots supplémentaires comptés ERREEEUUUUUURRR
            syllabes += result[1][1]                            # Ajout du nombre de syllabe calculés par la 2nde recherche
            if result[0] !=[]:                                    # Si au moins un mot n'est pas présent dans le dictionnaire alors 
                resultat.append(result[0])                        # ajout à la liste de retour des mots non traités
    except :
        print "Erreur dans le traitement des données"            # En cas d'erreur 
    #Calcul de l'indice de Lisibilité
    try :
        fre = 206.835 - 1.015 * mots / nphrases - 84.6 * syllabes / mots
        result_char ="nombre de phrase : "+nphrases+ \
    +espaceur \
    +"nombre de mots : "+mots+ \
    +espaceur \
    +"nombre de syllabes : "+syllabes+ \
    +espaceur \
    +"FRE : "+fre
        # Affichag du resultat et des variables du calcul
    except ZeroDivisionError:
        result_char =" Indice de lisibilité non valide : Nombre de phrases nul "
    return result_char

# 2nde fonction de recherche dans un dictionnaire 
# Paramètres d'entrées : # liste dont les éléments sont les mots à analyser
#                         # dictionnaire de référence

def last_lookup(liste,dictionnaire):
    # Initialisation
    fail_list = []
    syllabes =0
    mots =0
    # Gestion des erreurs lors de la recherche dans le dictionnaire
    try :
        # Pour chacun des mots de la liste 
        for mot_compose in liste:
            mot_compose = mot_compose.replace("'", " ").replace("-", " ").replace("_"," ").split(" ") # on remplace les ' et - par des espaces et l'on crée une nouvelle liste ERRRREUR 
            # Pour chacun des mots contenus dans la liste découpée
            for mot  in mot_compose :
                if (mot == "") :                                                    # On ignore le caractère vide
                    continue
                else :                                                                # Sinon 
                    syllabes += eval(dic[mot])                                        # Récupération du nombre de syllabe(s) associées
                    mots += 1                                                        # Additionne le nombre de mots
    except KeyError :                                                                # Erreur traitée : mots non présent dans le dico
        fail_list.append(mot)                                                        # Ajout du mot non traité à la liste de retour
    result_liste =((fail_list),(mots,syllabes))                                        # Création de la liste de retour
    return result_liste                                                                

# Fonction de découpage d'une liste (séparation des mots)
# Paramètre d'entrée : liste à découper
# Paramètre de retour : liste mise en forme et découpée     

def split_list_mots(liste):
    # Mise en forme (minuscule, retire les caractères '"', ',' et '\t' ' ')
    liste = liste.replace(",","").replace('"', "").strip(" ").strip("\t").strip(" ").lower()
    # Découpage de la liste pour séparer les mots contenus entre deux espaces
    liste_mots = liste.split(" ")
    return liste_mots
    
# Fonction de création d'un dictionnaire 
# Paramètres d'entrées : # lexique
#                         # Nombre de lignes présentes au début du texte à ignorer
#                         # Position dans le lexique du mot servant de clé au dictionnaire
#                         # Position dans le lexique du nombre de syllabe servant de résultat dans le dico
       
def create_dictionary(file_in,ind1,ind2,ind3):
    liste = file_in.split("\n")
    # Suppression des "ind1" premières colones inutiles (données de type descriptive)
    del liste[:ind1]
    
    # création du dictionnaire
    
    # Mise en forme des données brutes
    l=[]
    for i in liste:                                                # Pour chacune des lignes 
        i = i.split("\t")                                        # Création d'une liste contenant les différentes info pour chaque mot
        if (len(i) < ind3) :                                    # Vérification en cas d'irrégularité du lexique
            continue
        else :                                                    # Création d'une liste contenant le mots et le nombre de syllabes associées
            l.append((i[ind2], i[ind3]))                         # position 0 et 23 pour nous
    dic = dict(l)                                                 # Création du dictionnaire
 
    return dic

# Fonction utilisée pour les mots dont l'entrée n'existe pas dans le dictionnaire
# Vise à combiner deux mots et voir si ce dernier existe dans le dernier (cas "a jeun", "a l'instar" ...)
# Paramètres d'entrée : Liste de mots à combiner
#                        Dictionnaire
# Paramètre de sortie : liste des mots non trouvés, mots comptés, syllabes trouvées
    
    
    
def two_words_in_one_lookup (liste, dictionnaire):
    # Initialisation
    fail_list = []
    mots = 0
    syllabes = 0
                                                                                # Si le mot "Combo" est dans le dictionnaire alors 
    if ((liste[0] + " " + liste[1]) in dictionnaire) :
        new_mot = liste[0] + " " + liste[1]
        syllabes = eval(dictionnaire[new_mot])                                     # Calcul du nombre de syllabes correspondantes
        mots = len(new_mot.replace("'", " ").replace("-", " ").split(" "))        # Calcul du nombre de mots contenus dans ce mot combo
    else :                                                                        
        fail_list.append(liste[0])                                                # Sinon on ajoute les deux mots à la liste des mots 
        fail_list.append(liste[1])                                                # non traités  
    return_list = [(fail_list), (mots, syllabes)]                                # Création de la liste de retour
    return return_list

# Fonction de recherche de chacun des mots contenus dans un dictionnaire
# Paramètres d'entrée : # Liste dont les éléments sont les mots à analyser
#                        # Dicionnaire 
# Paramètre de retour : # Liste contenant les mots non trouvés, et pour les recherche valide, le nombre de syllabes et mots trouvés    
    
def lookup_list_in_dic (liste, dictionnaire):
    # Initialisation
    syllabes = 0
    fail_list = []
    mots = 0
    tampon =['']*2                                # Variable tampon pour contenir deux mots à analyser de manière conjointe
    match_word = "DeadBeeF"                        # Cas particulier - Initialisation avec une valeur ne matchan pas
    for mot in liste:                                # Pour chacun des mots contenus dans la liste                                
        if mot == "":                                # On ignore le caractère vide 
            continue
        elif mot in dictionnaire :                    # si le mot est dans le dictionnaire
            syllabes_tmp = eval(dictionnaire[mot])  # Calcul du nombre de syllabes
            syllabes +=syllabes_tmp
            temp = mot.replace("-", " ").replace("'", " ").split(" ") # Calcul du nombre de mot à contenus dans le mot analysé
            mots_tmp = len(temp)                                      # Additionne au nombre actuel de mots
            mots += mots_tmp
            match_word = mot
            tampon[0]=mot                                             # Mise en mémoire du dernier mot matché
        else :
            tampon[1]=mot                                             # Mise en mémoire du mot non matché
            result =two_words_in_one_lookup(tampon,dictionnaire)     # Tentative de combiner les deux mots 
            if result[1][0] != 0:                                     # Si match alors 
                mots -=mots_tmp                                         # décompte du dernier mot matché déjà compté
                syllabes -=syllabes_tmp                                 # décompte du nombre de syllabes déjà comptés
                mots += result[1][0]                                 # Ajout du nombre de syllabes / mots trouvées
                syllabes += result[1][1]        
            else :
                if match_word != tampon[0]:                            # Gestion du cas ou deux mots successifs sont non matchés
                    fail_list.append(tampon[0])                        # Ajout des deux mots non matchés à la liste de retour des mots non matchés
                    fail_list.append(tampon[1])
                else :
                    # Cas ou le mot combo ne match pas dans le lexique, mais que le mot 0 match
                    # alors on ajoute seulement le mot 1 à la liste de retour
                    fail_list.append(tampon[1])
            tampon[0]=mot                                            # Mise à jour des valeurs
            mots_tmp = 0
            syllabes_tmp = 0
    return_list = [(fail_list), (mots, syllabes)]                    # Création de la liste de retour
    return return_list

def dictionnaire_lab_2_init ():
    file_in = urllib.urlopen("http://www.cours.polymtl.ca/inf8007/Tp/20121/Lexique372.txt")
    file_in = file_in.read().decode('latin1 ').encode ('utf8 ')
    dic =create_dictionary( file_in,0,0,23)
    return dic

if __name__ == '__main__':
    # recuperation du fichier a analyser
    dic = dictionnaire_lab_2_init ()
    result = line_processing(data) 
    
    #    print "Liste de(s) mot(s) non comptabilisé(s)"
    #       for i in result[0]:
#        print i

